/*
   ============================================================================

// @todo: zugzwang auch wenn dame erhalten
// @todo: man ist nur mit einer figur im zugzwang pro runde


   Programmname: checkers.c
   Autor       : Sebastian Spiller
                 HHBK Gruppe A
   Datum       : 07.05.2011
   Projekt     : C-Spiele
   Version     : 1.0
   Aenderung   : -

   Programmschnittstelle: int main(void)
                          Das Programm gibt den Wert 0, 1, oder 2 zurueck.
                          0: Spielabbruch,
                          1: Sieg Spieler 1,
                          2: Sieg Spieler 2

                          Es werden keine Argumente erwartet.


   Hier wird Brett und Spiellogik von Checkers (Dame) implementiert.

   ============================================================================
*/


/*
============================================================================
Pr\204prozessoranweisungen
============================================================================
*/

/* Enthaelt Prototypen und kennzeichnet globale Variablen 
Praeprozessor waehlt Systemspezifische Funktionen */
#include "checkers.h"
#include "header.h"


/*
   ============================================================================
   Globale Variablen
   ============================================================================
*/
int aiBoard[8][8] = {   {1,0,1,0,1,0,1,0},
                        {0,1,0,1,0,1,0,1},
                        {1,0,1,0,1,0,1,0},
                        {0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0},
                        {0,2,0,2,0,2,0,2},
                        {2,0,2,0,2,0,2,0},
                        {0,2,0,2,0,2,0,2}
                    };

char acSchachbrett[B_NO_OF_ROWS][B_NO_OF_COLS];
char acErrorMsg[1024];
char acEvent[1024];

/**
 * Erzeugt Brett und Eingabe
 * @param  void
 * @return int
            0: Spielabbruch,
            1: Sieg Spieler 1,
            2: Sieg Spieler 2
 */
int checkers(void)
{
    int aiMove[2][2];
    int aiStart[2][2];

    int iPlayer     = 1;
    int iNextPlayer = 0;
    int iIsWon      = FALSE;
    int iErrorFlag  = FALSE;
    int iFirstRound = TRUE;

    acErrorMsg[0]       = '\0';
    acEvent[0]          = '\0';

    aiMove[START][ROW]  = 0;
    aiMove[START][COL]  = 0;
    aiMove[TARGET][ROW] = 0;
    aiMove[TARGET][COL] = 0;

    do
    {
        clrscr();

        if (FALSE == iFirstRound)
        {
            printf("\nZugkoordinaten:");
            printf("%c%c",  65 + aiMove[START][COL], 49 + aiMove[START][ROW]);
            printf(" - %c%c\n", 65 + aiMove[TARGET][COL], 49 + aiMove[TARGET][ROW]);
        } // if
        else
        {
            printf("Welcome 2 Checkers\n\n");
            printf("Abbruch mit x oder X + Enter\n\n");
            iFirstRound = FALSE;
        } // else

        if ('\0' != acErrorMsg[0])
        {
            printf("Fehler: %s", acErrorMsg);
            printf("Spieler %i, ziehe erneut\n\n", iPlayer);
        } // if
        else
        {
            if ('\0' != acEvent[0])
                printf("Ereignis: %s",acEvent);
            
            printf("Spieler %i an der Reihe\n\n", iPlayer);
        } // else

        acErrorMsg[0] = '\0';
        acEvent[0] = '\0';
        printBoard();

        // Fehler-Validierung mit Zugeingabe in getMove
        if (TRUE == getMove(aiMove))
        {
            // Zug des Spielers mit Fehlerausgabe ueber Global acErrorMsg
            if ( FALSE != checkMove(aiMove, iPlayer, TRUE) )
            {
                // Herrscht Zugzwang?
                if (2 == checkMustMove(iPlayer))
                {
                    if (FALSE == checkJumpMade(aiMove))
                        strcat(acErrorMsg, "Du musst springen!\n");
                    else
                    {
                        moveToken(aiMove, iPlayer);

                        aiStart[START][ROW] = aiMove [TARGET][ROW];
                        aiStart[START][COL] = aiMove [TARGET][COL];

                        // Zugzwang naechste Runde? Dann kein Spielerwechsel
                        if (FALSE == checkMoveQueue(aiStart, iPlayer))
                        {
                            iPlayer = changePlayers(iPlayer);

                            // Hat naechster Spieler noch Zugmoeglichkeiten?
                            if ( TRUE == checkGameStatus(iPlayer) )
                                iIsWon = TRUE;
                        } // if

                    } // else
                } // if
                else
                {
                    moveToken(aiMove, iPlayer);
                    iPlayer = changePlayers(iPlayer);

                    // Hat naechster Spieler noch Zugmoeglichkeiten?
                    if ( TRUE == checkGameStatus(iPlayer) )
                        iIsWon = TRUE;
                } // else
            } // if
        } // if
        else if (3 == getMove(aiMove))
            return ABBRUCH;

    }
    while (FALSE == iIsWon);

    clrscr();

                        
    iPlayer = changePlayers(iPlayer);
    printf("\n\nGewinner ist Spieler %i\n\n", iPlayer);
    printBoard();
    getchar();

    return iPlayer;
} // function




/**
* Ueberprueft ob noch ein weiterer einfacher Zug moeglich ist
* @param  int aiMove[2][2] Token-Koordinaten [Row, Column]
* @param  int iPlayer   SpielerID des Spielers, der dran ist
* @return int TRUE / FALSE  Gibt an, ob noch ein Zug moeglich ist
*/
int checkMovePossible(int aiMove[2][2], int iPlayer)
{
 // prueft nicht die richtung, uebernimmt checkMove dafuer
    int iReturn      = FALSE;
    int iCounter     = 0;

    // Ist der Stein vom Spieler, der am Zug ist?
    if ( TRUE == checkIsTokenFromPlayer(aiMove, iPlayer) )
    {
        for (iCounter = -1; ( (iCounter <= 1) && (iReturn != TRUE) ); iCounter++)
        {
            aiMove[TARGET][ROW] = aiMove[START][ROW] + iCounter;
            aiMove[TARGET][COL] = aiMove[START][COL] + iCounter;

            // Ist noch ein Zug moeglich? Bedingung funktioniert als Flag
            if ( TRUE == checkMove(aiMove, iPlayer, FALSE) )
                iReturn = TRUE;
        } // for
    } // if
    
    return iReturn;

} // function

/**
* Ueberprueft ob noch ein weiterer Zug moeglich ist
* @param  int aiStart[2][2] Token-Koordinaten [Row, Column]
* @param  int iPlayer   SpielerID des Spielers, der dran ist
* @return int TRUE / FALSE  Gibt an, ob noch ein Zug moeglich ist
*/
int checkIsTokenFromPlayer(int aiStart[2][2], int iPlayer)
{
    int iReturn = FALSE;

    switch (aiBoard[aiStart[START][ROW]][aiStart[START][TARGET]])
    {
        case 1:
        case 3:
            iReturn = ((iPlayer == 1) ? TRUE : FALSE );
            break;

        case 2:
        case 4:
            iReturn = ((iPlayer == 2) ? TRUE : FALSE );
            break;

        default:
            iReturn = FALSE;
    } // switch

    return iReturn;

} // function



/**
* Ueberprueft, ob uebermittelter Spieler weitere Zuege hat
* @param  int iPlayer SpielerID des Spielers, der am Zug ist
* @return int         0 (FALSE): Spieler hat keinen Zug mehr
*                     1 (TRUE):  Spieler hat noch Zug
*/
int checkGameStatus(int iPlayer)
{
    int iReturn       = TRUE;
    int iRow          = 0;
    int iCol          = 0;
    int aiStart[2][2];

    for (iRow = 0; iRow <= NO_OF_ROWS; iRow++)
    {
        for (iCol = 0; (iCol <= NO_OF_COLS); iCol++)
        {
            // Liegt ein Stein auf dem Feld?
            if (0 != aiBoard[iRow][iCol])
            {

                // @todo: hier auch
                aiStart[START][ROW] = iRow;
                aiStart[START][COL] = iCol;

                // Spielzug moeglich?
                if (TRUE == checkMovePossible(aiStart, iPlayer))
                    iReturn = FALSE;
            } // if
        } // for
    } // for

    return iReturn;
} // function


/**
* Ueberprueft, ob uebermittelter Spieler ziehen muss
* @param  int iPlayer SpielerID des Spielers, der am Zug ist
* @return int         0 (FALSE): Spieler hat keinen Zug mehr
*                     1 (TRUE):  Spieler hat noch Zugzwang
*/
int checkMustMove(int iPlayer)
{
    int iReturn       = TRUE;
    int iRow          = 0;
    int iCol          = 0;
    int aiStart[2][2];

    for (iRow = 0; iRow <= NO_OF_ROWS; iRow++)
    {
        for (iCol = 0; (iCol <= NO_OF_COLS); iCol++)
        {
            // Liegt ein Stein auf dem Feld?
            if (0 != aiBoard[iRow][iCol])
            {
                aiStart[START][ROW] = iRow;
                aiStart[START][COL] = iCol;

                // Spielzugzwang noetig?
                if (TRUE == checkMoveQueue(aiStart, iPlayer))
                    iReturn = 2;
            } // if
        } // for
    } // for

    return iReturn;
} // function




/**
 * Ueberprueft ob der Zugfolge eingetreten
 * @param  int aiStart[2][2] Zug mit Start und Zielkoordinaten [Start/Ziel][Row/Column]
 * @param  int iPlayer      Spieler, der am Zug ist
 * @return int TRUE / FALSE Ist Zug moeglich?
 */
int checkMoveQueue(int aiStart[2][2], int iPlayer)
{
    int i = 0;
    int j = 0;
    int iReturn = FALSE;
    int aiAroundStart[2][2];

    if (FALSE == checkIsTokenFromPlayer(aiStart, iPlayer))
        return FALSE;

    if (1 == iPlayer)
        i = 1;

    else if (2 == iPlayer)
        i = -1;

    // Ist Figur Dame?
    else if ( 2 < aiBoard[aiStart[START][ROW]][aiStart[START][COL]])
    {
        i = -1;
        for (j = -1; j <= 1; j += 2)
        {
            aiAroundStart[START][ROW] = aiStart[START][ROW] + i;
            aiAroundStart[START][COL] = aiStart[START][COL] + j;

            if (0 !=  aiBoard[aiAroundStart[START][ROW]][aiAroundStart[START][COL]])
            {
                if (FALSE == checkIsTokenFromPlayer(aiAroundStart, iPlayer))
                {
                    if ( 0 == (aiBoard[aiStart[START][ROW] + 2 * i][aiStart[START][COL] + 2 * j]) )
                        iReturn = TRUE;
                } // if
            } // if
        } // for
        i = 1;
    } // else if

    if (0 != i)
    {
        for (j = -1; j <= 1; j += 2)
        {
            aiAroundStart[START][ROW] = aiStart[START][ROW] + i;
            aiAroundStart[START][COL] = aiStart[START][COL] + j;

            if (0 != aiBoard[aiAroundStart[START][ROW]][aiAroundStart[START][COL]])
            {
                if (FALSE == checkIsTokenFromPlayer(aiAroundStart, iPlayer))
                {
                    if ( 0 == (aiBoard[aiStart[START][ROW] + 2 * i][aiStart[START][COL] + 2 * j]) )
                        iReturn = TRUE;
                } // if
            } // if
        } // for
    } // if
    
    i = 0;
    
    return iReturn;
} // function



/**
 * Figur schlagen
 * @param  int aiMove[2][2] Zug mit Start und Zielkoordinaten [Start/Ziel][Row/Column]
 * @param  int iPlayer      Spieler an der Reihe
 * @return int TRUE / FALSE Ist Figur geschalgen worden?
 */
int kickToken(int aiMove[2][2], int iPlayer)
{
    int iReturn = FALSE;
    int iEnemyRow = 0;
    int iEnemyCol = 0;

    if (     (  ( 2  == (aiMove[TARGET][ROW] - aiMove[START][ROW]) )
            ||( (-2) == (aiMove[TARGET][ROW] - aiMove[START][ROW]) )  )   )
    {
        if( 0 < (aiMove[TARGET][ROW] - aiMove[START][ROW]) )
            iEnemyRow = aiMove[START][ROW] + 1;
        else
            iEnemyRow = aiMove[START][ROW] -1;

        if( 0 < (aiMove[TARGET][COL] - aiMove[START][COL]) )
            iEnemyCol = aiMove[START][COL] + 1;
        else
            iEnemyCol = aiMove[START][COL] -1;

        aiBoard[iEnemyRow][iEnemyCol] = 0;
        iReturn = TRUE;

    } // if
    return iReturn;
} // function



/**
 * Ueberprueft ob der Zug legal ist
 * @param  int aiMove[2][2] Zug mit Start und Zielkoordinaten [Start/Ziel][Row/Column]
 * @param  int iPlayer      Spieler, der am Zug ist
 * @param  int iShowErrors  Wenn Computer mgl Zuege prueft, dann keine Errors senden
 * @return int TRUE / FALSE Ist Zug moeglich?
 */
int checkMove(int aiMove[2][2], int iPlayer, int iShowErrors)
{
    int iCheck   = TRUE;
    int iStart   = 0;
    int iTarget  = 0;
    int iMoveCol = 0; // Differenz aus Start- und Endkoordinaten in Spaltenrichtung
    int iMoveRow = 0; // analog

    char acErrorCache[1024]; 
    char acEventCache[1024];

    int iTargetRow = aiMove[TARGET][ROW];
    int iTargetCol = aiMove[TARGET][COL];

    acErrorCache[0] = '\0'; 
    acEventCache[0] = '\0'; 

    iStart  = aiBoard[aiMove[START][ROW]][aiMove[START][COL]];
    iTarget = aiBoard[iTargetRow][iTargetCol];

    iMoveCol = aiMove[TARGET][COL] - aiMove[START][COL];
    iMoveRow = aiMove[TARGET][ROW] - aiMove[START][ROW];


    // Eingabefeld == Ausgabefeld
    if (  ( aiMove[START][ROW] ==  aiMove[TARGET][ROW])
       && ( aiMove[START][COL] ==  aiMove[TARGET][COL]) )
    {
        iCheck = FALSE;
        strcat(acErrorCache, "Startfeld und Zielfeld identisch\n");
    } // if


    // Startfeld leer
    if ( 0 == aiBoard[aiMove[START][ROW]][aiMove[START][COL]] )
    {
        iCheck = FALSE;
        strcat(acErrorCache, "Startfeld ist leer\n");
    } // if


    // ZielFeld besetzt
    if ( 0 != aiBoard[aiMove[TARGET][ROW]][aiMove[TARGET][COL]] )
    {
        iCheck = FALSE;
        strcat(acErrorCache, "Zielfeld ist besetzt\n");
    } // if


    // Figur nicht vom Spieler
    if ( FALSE == checkIsTokenFromPlayer(aiMove, iPlayer) )
    {
        iCheck = FALSE;
        strcat(acErrorCache, "Spielfigur ist vom Gegner\n");
    } // if


    // Zug nicht diagonal
    if ( ( iMoveCol != iMoveRow ) && ((iMoveCol * (-1)) != iMoveRow) )
    {
        iCheck = FALSE;
        strcat(acErrorCache, "Spielzug ist nicht diagonal\n");
    } // if


    // Sprungweite zu gross
    if (    (  2 < (aiMove[TARGET][ROW] - aiMove[START][ROW]) )
          ||( -2 > (aiMove[TARGET][ROW] - aiMove[START][ROW]) )  )
    {
        iCheck = FALSE;
        strcat(acErrorCache, "Sprung zu weit\n");
    } // if


   // Handelt es sich nicht um eine Dame?
    if ( 3 > iStart)
    {
        // Zugrichtung korrekt?
        if ( (1 == iPlayer) && (aiMove[TARGET][ROW] < aiMove[START][ROW]) )
        {
            iCheck = FALSE;
            strcat(acErrorCache, "Zugrichtung fuer einfache Spielfigur nur nach oben \n");
        } // if
        
        // Zugrichtung korrekt?
        if ( (2 == iPlayer) && (aiMove[TARGET][ROW] > aiMove[START][ROW])  )
        {
            iCheck = FALSE;
            strcat(acErrorCache, "Zugrichtung fuer einfache Spielfigur nur nach unten \n");
        } // else if
    } // if

// @todo: Prooch: Stein nicht schlagen beim Spielfeld-Check
    if ( (TRUE == iCheck ) && (TRUE == iShowErrors ) && (TRUE == checkMoveQueue(aiMove, iPlayer)) )
    {
        // Checked ob Kicken erlaubt ist // IPLAYER
        if ( FALSE == kickToken(aiMove, iPlayer) )
            strcat(acEventCache, "Du musst schlagen!\n");
        else
        {
            // @todo: Prooch fuer Stein geschlagen zurueckgeben sonst glob var?!
            iCheck = 2;
            strcat(acEventCache, "Gegnerischen Stein geschlagen!\n");
        } // else
    } // if


    // Fehler an Fehlerausgabe weiterleiten
    if (TRUE == iShowErrors)
    {
        strcat(acErrorMsg, acErrorCache);
        strcat(acEvent, acEventCache);
    } // if

    /* Cache leeren */
    acErrorCache[0] = '\0';
    acEventCache[0] = '\0';
    
    return iCheck;
} // function


/**
* Fuehre Spielzug aus
* @param void
* @param int aiMove[2][2] SpielZug
*/
void moveToken(int aiMove[2][2], int iPlayer)
{
    int iToken = 0;

    iToken = aiBoard[aiMove[START][ROW]][aiMove[START][COL]];

    aiBoard[aiMove[START][ROW]][aiMove[START][COL]]   = 0;
    aiBoard[aiMove[TARGET][ROW]][aiMove[TARGET][COL]] = iToken;

    // mache Figur zur Dame, nur wenn natuerlich einfache Figur
    if (
           ( (7 == aiMove[TARGET][ROW]) && (1 == iPlayer) && (2 >= iToken) )
        || ( (0 == aiMove[TARGET][ROW]) && (2 == iPlayer) && (2 >= iToken) )
       )
    {
        aiBoard[aiMove[TARGET][ROW]][aiMove[TARGET][COL]] +=2;
        if (1 == iPlayer)
            strcat(acEvent,"Spieler 1 hat eine Dame bekommen.\n");
        else
            strcat(acEvent,"Spieler 2 hat eine Dame bekommen.\n");
    } // if
    
} // function

/**
* Kontrolliert den Spielerwechsel (flipflop zwischen 1 und 2)
* @param  int iPlayer ID des aktuellen Spielers
* @return int         ID des folgenden Spielers
*/
int changePlayers(int iPlayer)
{
    return (iPlayer == 1) ? 2 : 1;
} // function


/**
* Ueberprueft ob ein Sprung gemacht wurde
* @param  int aiMove[2][2] Token-Koordinaten [Row, Column]
* @return int TRUE / FALSE  Gibt an, ob noch ein Zug moeglich ist
*/
int checkJumpMade(int aiMove[2][2])
{
    if (  (-2 != (aiMove[TARGET][ROW] - aiMove[START][ROW]))
          && ( (aiMove[TARGET][ROW] - aiMove[START][ROW]) != 2 )  )
        return FALSE;
    else
        return TRUE;
} // function


/** 
* Zahl zu Spielfigur verwandeln
* @param  int  iNumber Figuren-Zahl
* @return char Figuren-Symbol
*/
char changeNumberToToken(int iNumber)
{
    char cToken = '\0';

    switch(iNumber)
    {
        case 1:
            cToken = 'X';
            break;
        case 2:
            cToken = 'O';
            break;
        case 3:
            cToken = 'x';
            break;
        case 4:
            cToken = 'o';
    } // select
    return cToken;
} // function


/** 
* Schachbrettkopf erzeugen
* @param void
* @return void
*/
void FillFirst2Lines(void)
{
        int iCol;

    acSchachbrett[0][0] = ' ';

    for (iCol=2;iCol < B_NO_OF_COLS;iCol++) /* Spalten */
        acSchachbrett[0][iCol] = 63+iCol;

    for (iCol=0;iCol< B_NO_OF_COLS;iCol++) /* Spalten */
        acSchachbrett[1][iCol] = FIELD_BORDER_C;

} // function



/** 
* Linken Schachbrettrand erzeugen
* @param  void
* @return void
*/
void FillFirst2Columns(void)
{
        int iRow;

        for (iRow=2; iRow < B_NO_OF_ROWS; iRow++) /* Zeilen */
            acSchachbrett[iRow][0] = 47 + (11 - iRow);

        acSchachbrett[1][1] = FIELD_BORDER_A;

        for (iRow=0;iRow< B_NO_OF_ROWS;iRow++) /* Zeilen */
            acSchachbrett[iRow][1] = FIELD_BORDER_B;
} // function



/** 
* Spielbrett erstellen
* @param void
* @return TRUE / FALSE
*/
int printBoard(void)
{

    int iRow      = 0;
    int iCol      = 0;


    FillFirst2Lines();
    FillFirst2Columns();

    for (iRow= 0; iRow < NO_OF_ROWS; iRow++)
    {
        for (iCol = 0; iCol < NO_OF_COLS; iCol++)
        {
            if ( 0 < aiBoard[NO_OF_ROWS - 1 - iRow][iCol] )
                acSchachbrett[iRow + 2][iCol + 2] = changeNumberToToken(aiBoard[NO_OF_ROWS - 1 - iRow][iCol]);
            else
            {
                if (iRow % 2 == 0)
                {
                    if (iCol % 2 == 0)
                        acSchachbrett[iRow + 2][iCol + 2] = FIELD_A;
                    else
                        acSchachbrett[iRow + 2][iCol + 2] = FIELD_B;
                } // if
                else
                {
                    if (iCol % 2 != 0)
                        acSchachbrett[iRow + 2][iCol + 2] = FIELD_A;
                    else
                        acSchachbrett[iRow + 2][iCol + 2] = FIELD_B;
                } // else
           } // else
        } // for
    } // for


// Schachbrett ausgeben
    for ( iRow = 0; iRow < B_NO_OF_ROWS; iRow++) 
    {
        for (iCol = 0; iCol < B_NO_OF_COLS; iCol++) 
        {
            printf("%c", acSchachbrett[iRow][iCol]);
        } // for
        printf("\n");
    } // for

    return TRUE;

} // function




/**
* Liest Zugeingabe per Tastatur ein
* @param  int          aiMove[2][2]
* @return TRUE / FALSE Eingabe erfolgreich
*/
int getMove(int aiMove[2][2])
{
    int  iCounter = 0; /* Zaehlvariable */
    char acTestStr[256] = {'\0'};
    char acErrorCache[1024] = {'\0'};
    int  iReturn = TRUE;

        for (iCounter = 0; iCounter <= 1; iCounter++)
        {
            if (0 == iCounter)
                printf("\nBitte Startzug eingeben (a1 oder A2, ...)\t");
            else
                printf("Bitte Zielzug eingeben    (a1 oder A2, ...)\t");


            scanf("%s", acTestStr);
            fflush(stdin);

            // Abbruch mit x oder X
            if ( ( (acTestStr[0] == 'x') || (acTestStr[0] == 'X') ) && (acTestStr[1] == '\0') )
                return 3;

            // Eingabe nicht zwei Zeichen lang
            if ('\0' != acTestStr[2])
            {
                iReturn = FALSE;
                strcat(acErrorCache, "Eingabe fuer Zug darf nur zwei Zeichen lang sein.\n");
            } // if



            //  Erstes Zeichen ist kein kleiner bzw grosser Buchstabe A bis H
            if ( ( 97 <= (int)acTestStr[0]) || ((int)acTestStr[0] <= 104 ) )
            {
            }
            else if ( ( 65 <= (int)acTestStr[0]) || ((int)acTestStr[0] <= 72 ) )
            {
            } // else if
            else
            {
                iReturn = FALSE;
                strcat(acErrorCache, "Erstes Zeichen kein Buchstabe aus (A-H oder a-h).\n");
            } // if


            // Zweites Zeichen ist eine Zahl von 1 bis 8
            if ( ((int)acTestStr[1] < 49 ) || (56 < (int)acTestStr[1]) )
            {
                iReturn = FALSE;
                strcat(acErrorCache, "Zweites Zeichen keine Zahl zwischen (1-8).\n");
            } // if


            if (TRUE == iReturn)
            {
                // kleines a-h ? dann Wertigkeit des Asciizeichens 'a' abziehen
                if ( (97 <= (int)acTestStr[0]) && ((int)acTestStr[0] <= 104) )
                    aiMove[iCounter][COL] = (int)acTestStr[0] - 97;
                else
                    aiMove[iCounter][COL] = (int)acTestStr[0] - 65;

                aiMove[iCounter][ROW] = (int)acTestStr[1] - 49;
            } // if
            else
            {
                if (0 == iCounter )
                    strcat(acErrorMsg, "Erste Eingabe fehlerhaft:\n");
                else
                    strcat(acErrorMsg, "Zweite Eingabe fehlerhaft:\n");

                strcat(acErrorMsg, acErrorCache);
                strcpy(acErrorCache, "");
            } // else
        } // for

    return iReturn;

} // function
